// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/carnot/planner/distributedpb/distributed_plan.proto

package distributedpb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	io "io"
	math "math"
	math_bits "math/bits"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
	planpb "px.dev/pixie/src/carnot/planpb"
	statuspb "px.dev/pixie/src/common/base/statuspb"
	bloomfilterpb "px.dev/pixie/src/shared/bloomfilterpb"
	metadatapb "px.dev/pixie/src/shared/metadatapb"
	schemapb "px.dev/pixie/src/table_store/schemapb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type MetadataInfo struct {
	MetadataFields []metadatapb.MetadataType `protobuf:"varint,1,rep,packed,name=metadata_fields,json=metadataFields,proto3,enum=px.shared.metadatapb.MetadataType" json:"metadata_fields,omitempty"`
	// Types that are valid to be assigned to Filter:
	//	*MetadataInfo_XXHash64BloomFilter
	Filter isMetadataInfo_Filter `protobuf_oneof:"filter"`
}

func (m *MetadataInfo) Reset()      { *m = MetadataInfo{} }
func (*MetadataInfo) ProtoMessage() {}
func (*MetadataInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{0}
}
func (m *MetadataInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MetadataInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MetadataInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MetadataInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MetadataInfo.Merge(m, src)
}
func (m *MetadataInfo) XXX_Size() int {
	return m.Size()
}
func (m *MetadataInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_MetadataInfo.DiscardUnknown(m)
}

var xxx_messageInfo_MetadataInfo proto.InternalMessageInfo

type isMetadataInfo_Filter interface {
	isMetadataInfo_Filter()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type MetadataInfo_XXHash64BloomFilter struct {
	XXHash64BloomFilter *bloomfilterpb.XXHash64BloomFilter `protobuf:"bytes,2,opt,name=xxhash64_bloom_filter,json=xxhash64BloomFilter,proto3,oneof" json:"xxhash64_bloom_filter,omitempty"`
}

func (*MetadataInfo_XXHash64BloomFilter) isMetadataInfo_Filter() {}

func (m *MetadataInfo) GetFilter() isMetadataInfo_Filter {
	if m != nil {
		return m.Filter
	}
	return nil
}

func (m *MetadataInfo) GetMetadataFields() []metadatapb.MetadataType {
	if m != nil {
		return m.MetadataFields
	}
	return nil
}

func (m *MetadataInfo) GetXXHash64BloomFilter() *bloomfilterpb.XXHash64BloomFilter {
	if x, ok := m.GetFilter().(*MetadataInfo_XXHash64BloomFilter); ok {
		return x.XXHash64BloomFilter
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*MetadataInfo) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*MetadataInfo_XXHash64BloomFilter)(nil),
	}
}

type CarnotInfo struct {
	QueryBrokerAddress   string        `protobuf:"bytes,1,opt,name=query_broker_address,json=queryBrokerAddress,proto3" json:"query_broker_address,omitempty"`
	AgentID              *uuidpb.UUID  `protobuf:"bytes,10,opt,name=agent_id,json=agentId,proto3" json:"agent_id,omitempty"`
	HasGRPCServer        bool          `protobuf:"varint,2,opt,name=has_grpc_server,json=hasGrpcServer,proto3" json:"has_grpc_server,omitempty"`
	GRPCAddress          string        `protobuf:"bytes,3,opt,name=grpc_address,json=grpcAddress,proto3" json:"grpc_address,omitempty"`
	HasDataStore         bool          `protobuf:"varint,4,opt,name=has_data_store,json=hasDataStore,proto3" json:"has_data_store,omitempty"`
	ProcessesData        bool          `protobuf:"varint,5,opt,name=processes_data,json=processesData,proto3" json:"processes_data,omitempty"`
	AcceptsRemoteSources bool          `protobuf:"varint,6,opt,name=accepts_remote_sources,json=acceptsRemoteSources,proto3" json:"accepts_remote_sources,omitempty"`
	TableInfo            []*TableInfo  `protobuf:"bytes,7,rep,name=table_info,json=tableInfo,proto3" json:"table_info,omitempty"`
	ASID                 uint32        `protobuf:"varint,8,opt,name=asid,proto3" json:"asid,omitempty"`
	MetadataInfo         *MetadataInfo `protobuf:"bytes,9,opt,name=metadata_info,json=metadataInfo,proto3" json:"metadata_info,omitempty"`
	SSLTargetName        string        `protobuf:"bytes,11,opt,name=ssl_targetname,json=sslTargetname,proto3" json:"ssl_targetname,omitempty"`
}

func (m *CarnotInfo) Reset()      { *m = CarnotInfo{} }
func (*CarnotInfo) ProtoMessage() {}
func (*CarnotInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{1}
}
func (m *CarnotInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CarnotInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CarnotInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CarnotInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CarnotInfo.Merge(m, src)
}
func (m *CarnotInfo) XXX_Size() int {
	return m.Size()
}
func (m *CarnotInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_CarnotInfo.DiscardUnknown(m)
}

var xxx_messageInfo_CarnotInfo proto.InternalMessageInfo

func (m *CarnotInfo) GetQueryBrokerAddress() string {
	if m != nil {
		return m.QueryBrokerAddress
	}
	return ""
}

func (m *CarnotInfo) GetAgentID() *uuidpb.UUID {
	if m != nil {
		return m.AgentID
	}
	return nil
}

func (m *CarnotInfo) GetHasGRPCServer() bool {
	if m != nil {
		return m.HasGRPCServer
	}
	return false
}

func (m *CarnotInfo) GetGRPCAddress() string {
	if m != nil {
		return m.GRPCAddress
	}
	return ""
}

func (m *CarnotInfo) GetHasDataStore() bool {
	if m != nil {
		return m.HasDataStore
	}
	return false
}

func (m *CarnotInfo) GetProcessesData() bool {
	if m != nil {
		return m.ProcessesData
	}
	return false
}

func (m *CarnotInfo) GetAcceptsRemoteSources() bool {
	if m != nil {
		return m.AcceptsRemoteSources
	}
	return false
}

func (m *CarnotInfo) GetTableInfo() []*TableInfo {
	if m != nil {
		return m.TableInfo
	}
	return nil
}

func (m *CarnotInfo) GetASID() uint32 {
	if m != nil {
		return m.ASID
	}
	return 0
}

func (m *CarnotInfo) GetMetadataInfo() *MetadataInfo {
	if m != nil {
		return m.MetadataInfo
	}
	return nil
}

func (m *CarnotInfo) GetSSLTargetName() string {
	if m != nil {
		return m.SSLTargetName
	}
	return ""
}

type TableInfo struct {
	Table            string   `protobuf:"bytes,1,opt,name=table,proto3" json:"table,omitempty"`
	TabletizationKey string   `protobuf:"bytes,2,opt,name=tabletization_key,json=tabletizationKey,proto3" json:"tabletization_key,omitempty"`
	Tablets          []string `protobuf:"bytes,3,rep,name=tablets,proto3" json:"tablets,omitempty"`
}

func (m *TableInfo) Reset()      { *m = TableInfo{} }
func (*TableInfo) ProtoMessage() {}
func (*TableInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{2}
}
func (m *TableInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TableInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TableInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TableInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TableInfo.Merge(m, src)
}
func (m *TableInfo) XXX_Size() int {
	return m.Size()
}
func (m *TableInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_TableInfo.DiscardUnknown(m)
}

var xxx_messageInfo_TableInfo proto.InternalMessageInfo

func (m *TableInfo) GetTable() string {
	if m != nil {
		return m.Table
	}
	return ""
}

func (m *TableInfo) GetTabletizationKey() string {
	if m != nil {
		return m.TabletizationKey
	}
	return ""
}

func (m *TableInfo) GetTablets() []string {
	if m != nil {
		return m.Tablets
	}
	return nil
}

type SchemaInfo struct {
	Name      string             `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Relation  *schemapb.Relation `protobuf:"bytes,2,opt,name=relation,proto3" json:"relation,omitempty"`
	AgentList []*uuidpb.UUID     `protobuf:"bytes,3,rep,name=agent_list,json=agentList,proto3" json:"agent_list,omitempty"`
}

func (m *SchemaInfo) Reset()      { *m = SchemaInfo{} }
func (*SchemaInfo) ProtoMessage() {}
func (*SchemaInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{3}
}
func (m *SchemaInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SchemaInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SchemaInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SchemaInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SchemaInfo.Merge(m, src)
}
func (m *SchemaInfo) XXX_Size() int {
	return m.Size()
}
func (m *SchemaInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_SchemaInfo.DiscardUnknown(m)
}

var xxx_messageInfo_SchemaInfo proto.InternalMessageInfo

func (m *SchemaInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *SchemaInfo) GetRelation() *schemapb.Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

func (m *SchemaInfo) GetAgentList() []*uuidpb.UUID {
	if m != nil {
		return m.AgentList
	}
	return nil
}

type DistributedState struct {
	CarnotInfo []*CarnotInfo `protobuf:"bytes,1,rep,name=carnot_info,json=carnotInfo,proto3" json:"carnot_info,omitempty"`
	SchemaInfo []*SchemaInfo `protobuf:"bytes,2,rep,name=schema_info,json=schemaInfo,proto3" json:"schema_info,omitempty"`
}

func (m *DistributedState) Reset()      { *m = DistributedState{} }
func (*DistributedState) ProtoMessage() {}
func (*DistributedState) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{4}
}
func (m *DistributedState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DistributedState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DistributedState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DistributedState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DistributedState.Merge(m, src)
}
func (m *DistributedState) XXX_Size() int {
	return m.Size()
}
func (m *DistributedState) XXX_DiscardUnknown() {
	xxx_messageInfo_DistributedState.DiscardUnknown(m)
}

var xxx_messageInfo_DistributedState proto.InternalMessageInfo

func (m *DistributedState) GetCarnotInfo() []*CarnotInfo {
	if m != nil {
		return m.CarnotInfo
	}
	return nil
}

func (m *DistributedState) GetSchemaInfo() []*SchemaInfo {
	if m != nil {
		return m.SchemaInfo
	}
	return nil
}

type DistributedPlan struct {
	QbAddressToPlan  map[string]*planpb.Plan `protobuf:"bytes,1,rep,name=qb_address_to_plan,json=qbAddressToPlan,proto3" json:"qb_address_to_plan,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	QbAddressToDagId map[string]uint64       `protobuf:"bytes,2,rep,name=qb_address_to_dag_id,json=qbAddressToDagId,proto3" json:"qb_address_to_dag_id,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Dag              *planpb.DAG             `protobuf:"bytes,3,opt,name=dag,proto3" json:"dag,omitempty"`
}

func (m *DistributedPlan) Reset()      { *m = DistributedPlan{} }
func (*DistributedPlan) ProtoMessage() {}
func (*DistributedPlan) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{5}
}
func (m *DistributedPlan) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DistributedPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DistributedPlan.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DistributedPlan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DistributedPlan.Merge(m, src)
}
func (m *DistributedPlan) XXX_Size() int {
	return m.Size()
}
func (m *DistributedPlan) XXX_DiscardUnknown() {
	xxx_messageInfo_DistributedPlan.DiscardUnknown(m)
}

var xxx_messageInfo_DistributedPlan proto.InternalMessageInfo

func (m *DistributedPlan) GetQbAddressToPlan() map[string]*planpb.Plan {
	if m != nil {
		return m.QbAddressToPlan
	}
	return nil
}

func (m *DistributedPlan) GetQbAddressToDagId() map[string]uint64 {
	if m != nil {
		return m.QbAddressToDagId
	}
	return nil
}

func (m *DistributedPlan) GetDag() *planpb.DAG {
	if m != nil {
		return m.Dag
	}
	return nil
}

type RedactionOptions struct {
	UseFullRedaction         bool `protobuf:"varint,1,opt,name=use_full_redaction,json=useFullRedaction,proto3" json:"use_full_redaction,omitempty"`
	UsePxRedactPiiBestEffort bool `protobuf:"varint,2,opt,name=use_px_redact_pii_best_effort,json=usePxRedactPiiBestEffort,proto3" json:"use_px_redact_pii_best_effort,omitempty"`
}

func (m *RedactionOptions) Reset()      { *m = RedactionOptions{} }
func (*RedactionOptions) ProtoMessage() {}
func (*RedactionOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{6}
}
func (m *RedactionOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedactionOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedactionOptions.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedactionOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedactionOptions.Merge(m, src)
}
func (m *RedactionOptions) XXX_Size() int {
	return m.Size()
}
func (m *RedactionOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_RedactionOptions.DiscardUnknown(m)
}

var xxx_messageInfo_RedactionOptions proto.InternalMessageInfo

func (m *RedactionOptions) GetUseFullRedaction() bool {
	if m != nil {
		return m.UseFullRedaction
	}
	return false
}

func (m *RedactionOptions) GetUsePxRedactPiiBestEffort() bool {
	if m != nil {
		return m.UsePxRedactPiiBestEffort
	}
	return false
}

type OTelEndpointConfig struct {
	URL      string            `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	Headers  map[string]string `protobuf:"bytes,2,rep,name=headers,proto3" json:"headers,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Insecure bool              `protobuf:"varint,3,opt,name=insecure,proto3" json:"insecure,omitempty"`
	Timeout  int64             `protobuf:"varint,4,opt,name=timeout,proto3" json:"timeout,omitempty"`
}

func (m *OTelEndpointConfig) Reset()      { *m = OTelEndpointConfig{} }
func (*OTelEndpointConfig) ProtoMessage() {}
func (*OTelEndpointConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{7}
}
func (m *OTelEndpointConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OTelEndpointConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OTelEndpointConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OTelEndpointConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OTelEndpointConfig.Merge(m, src)
}
func (m *OTelEndpointConfig) XXX_Size() int {
	return m.Size()
}
func (m *OTelEndpointConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_OTelEndpointConfig.DiscardUnknown(m)
}

var xxx_messageInfo_OTelEndpointConfig proto.InternalMessageInfo

func (m *OTelEndpointConfig) GetURL() string {
	if m != nil {
		return m.URL
	}
	return ""
}

func (m *OTelEndpointConfig) GetHeaders() map[string]string {
	if m != nil {
		return m.Headers
	}
	return nil
}

func (m *OTelEndpointConfig) GetInsecure() bool {
	if m != nil {
		return m.Insecure
	}
	return false
}

func (m *OTelEndpointConfig) GetTimeout() int64 {
	if m != nil {
		return m.Timeout
	}
	return 0
}

type PluginConfig struct {
	StartTimeNs int64 `protobuf:"varint,1,opt,name=start_time_ns,json=startTimeNs,proto3" json:"start_time_ns,omitempty"`
	EndTimeNs   int64 `protobuf:"varint,2,opt,name=end_time_ns,json=endTimeNs,proto3" json:"end_time_ns,omitempty"`
}

func (m *PluginConfig) Reset()      { *m = PluginConfig{} }
func (*PluginConfig) ProtoMessage() {}
func (*PluginConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{8}
}
func (m *PluginConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PluginConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PluginConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PluginConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PluginConfig.Merge(m, src)
}
func (m *PluginConfig) XXX_Size() int {
	return m.Size()
}
func (m *PluginConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_PluginConfig.DiscardUnknown(m)
}

var xxx_messageInfo_PluginConfig proto.InternalMessageInfo

func (m *PluginConfig) GetStartTimeNs() int64 {
	if m != nil {
		return m.StartTimeNs
	}
	return 0
}

func (m *PluginConfig) GetEndTimeNs() int64 {
	if m != nil {
		return m.EndTimeNs
	}
	return 0
}

type DebugInfo struct {
	OtelDebugAttributes []*DebugInfo_OTelDebugAttribute `protobuf:"bytes,1,rep,name=otel_debug_attributes,json=otelDebugAttributes,proto3" json:"otel_debug_attributes,omitempty"`
}

func (m *DebugInfo) Reset()      { *m = DebugInfo{} }
func (*DebugInfo) ProtoMessage() {}
func (*DebugInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{9}
}
func (m *DebugInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugInfo.Merge(m, src)
}
func (m *DebugInfo) XXX_Size() int {
	return m.Size()
}
func (m *DebugInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugInfo.DiscardUnknown(m)
}

var xxx_messageInfo_DebugInfo proto.InternalMessageInfo

func (m *DebugInfo) GetOtelDebugAttributes() []*DebugInfo_OTelDebugAttribute {
	if m != nil {
		return m.OtelDebugAttributes
	}
	return nil
}

type DebugInfo_OTelDebugAttribute struct {
	Name  string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *DebugInfo_OTelDebugAttribute) Reset()      { *m = DebugInfo_OTelDebugAttribute{} }
func (*DebugInfo_OTelDebugAttribute) ProtoMessage() {}
func (*DebugInfo_OTelDebugAttribute) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{9, 0}
}
func (m *DebugInfo_OTelDebugAttribute) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DebugInfo_OTelDebugAttribute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DebugInfo_OTelDebugAttribute.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DebugInfo_OTelDebugAttribute) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DebugInfo_OTelDebugAttribute.Merge(m, src)
}
func (m *DebugInfo_OTelDebugAttribute) XXX_Size() int {
	return m.Size()
}
func (m *DebugInfo_OTelDebugAttribute) XXX_DiscardUnknown() {
	xxx_messageInfo_DebugInfo_OTelDebugAttribute.DiscardUnknown(m)
}

var xxx_messageInfo_DebugInfo_OTelDebugAttribute proto.InternalMessageInfo

func (m *DebugInfo_OTelDebugAttribute) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DebugInfo_OTelDebugAttribute) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type LogicalPlannerState struct {
	DistributedState    *DistributedState   `protobuf:"bytes,2,opt,name=distributed_state,json=distributedState,proto3" json:"distributed_state,omitempty"`
	PlanOptions         *planpb.PlanOptions `protobuf:"bytes,3,opt,name=plan_options,json=planOptions,proto3" json:"plan_options,omitempty"`
	ResultAddress       string              `protobuf:"bytes,4,opt,name=result_address,json=resultAddress,proto3" json:"result_address,omitempty"`
	ResultSSLTargetName string              `protobuf:"bytes,5,opt,name=result_ssl_targetname,json=resultSslTargetname,proto3" json:"result_ssl_targetname,omitempty"`
	RedactionOptions    *RedactionOptions   `protobuf:"bytes,7,opt,name=redaction_options,json=redactionOptions,proto3" json:"redaction_options,omitempty"`
	OTelEndpointConfig  *OTelEndpointConfig `protobuf:"bytes,8,opt,name=otel_endpoint_config,json=otelEndpointConfig,proto3" json:"otel_endpoint_config,omitempty"`
	PluginConfig        *PluginConfig       `protobuf:"bytes,9,opt,name=plugin_config,json=pluginConfig,proto3" json:"plugin_config,omitempty"`
	DebugInfo           *DebugInfo          `protobuf:"bytes,10,opt,name=debug_info,json=debugInfo,proto3" json:"debug_info,omitempty"`
}

func (m *LogicalPlannerState) Reset()      { *m = LogicalPlannerState{} }
func (*LogicalPlannerState) ProtoMessage() {}
func (*LogicalPlannerState) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{10}
}
func (m *LogicalPlannerState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogicalPlannerState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogicalPlannerState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LogicalPlannerState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogicalPlannerState.Merge(m, src)
}
func (m *LogicalPlannerState) XXX_Size() int {
	return m.Size()
}
func (m *LogicalPlannerState) XXX_DiscardUnknown() {
	xxx_messageInfo_LogicalPlannerState.DiscardUnknown(m)
}

var xxx_messageInfo_LogicalPlannerState proto.InternalMessageInfo

func (m *LogicalPlannerState) GetDistributedState() *DistributedState {
	if m != nil {
		return m.DistributedState
	}
	return nil
}

func (m *LogicalPlannerState) GetPlanOptions() *planpb.PlanOptions {
	if m != nil {
		return m.PlanOptions
	}
	return nil
}

func (m *LogicalPlannerState) GetResultAddress() string {
	if m != nil {
		return m.ResultAddress
	}
	return ""
}

func (m *LogicalPlannerState) GetResultSSLTargetName() string {
	if m != nil {
		return m.ResultSSLTargetName
	}
	return ""
}

func (m *LogicalPlannerState) GetRedactionOptions() *RedactionOptions {
	if m != nil {
		return m.RedactionOptions
	}
	return nil
}

func (m *LogicalPlannerState) GetOTelEndpointConfig() *OTelEndpointConfig {
	if m != nil {
		return m.OTelEndpointConfig
	}
	return nil
}

func (m *LogicalPlannerState) GetPluginConfig() *PluginConfig {
	if m != nil {
		return m.PluginConfig
	}
	return nil
}

func (m *LogicalPlannerState) GetDebugInfo() *DebugInfo {
	if m != nil {
		return m.DebugInfo
	}
	return nil
}

type LogicalPlannerResult struct {
	Status *statuspb.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Plan   *DistributedPlan `protobuf:"bytes,2,opt,name=plan,proto3" json:"plan,omitempty"`
}

func (m *LogicalPlannerResult) Reset()      { *m = LogicalPlannerResult{} }
func (*LogicalPlannerResult) ProtoMessage() {}
func (*LogicalPlannerResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_30dce4250507a2af, []int{11}
}
func (m *LogicalPlannerResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogicalPlannerResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogicalPlannerResult.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LogicalPlannerResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogicalPlannerResult.Merge(m, src)
}
func (m *LogicalPlannerResult) XXX_Size() int {
	return m.Size()
}
func (m *LogicalPlannerResult) XXX_DiscardUnknown() {
	xxx_messageInfo_LogicalPlannerResult.DiscardUnknown(m)
}

var xxx_messageInfo_LogicalPlannerResult proto.InternalMessageInfo

func (m *LogicalPlannerResult) GetStatus() *statuspb.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *LogicalPlannerResult) GetPlan() *DistributedPlan {
	if m != nil {
		return m.Plan
	}
	return nil
}

func init() {
	proto.RegisterType((*MetadataInfo)(nil), "px.carnot.planner.distributedpb.MetadataInfo")
	proto.RegisterType((*CarnotInfo)(nil), "px.carnot.planner.distributedpb.CarnotInfo")
	proto.RegisterType((*TableInfo)(nil), "px.carnot.planner.distributedpb.TableInfo")
	proto.RegisterType((*SchemaInfo)(nil), "px.carnot.planner.distributedpb.SchemaInfo")
	proto.RegisterType((*DistributedState)(nil), "px.carnot.planner.distributedpb.DistributedState")
	proto.RegisterType((*DistributedPlan)(nil), "px.carnot.planner.distributedpb.DistributedPlan")
	proto.RegisterMapType((map[string]uint64)(nil), "px.carnot.planner.distributedpb.DistributedPlan.QbAddressToDagIdEntry")
	proto.RegisterMapType((map[string]*planpb.Plan)(nil), "px.carnot.planner.distributedpb.DistributedPlan.QbAddressToPlanEntry")
	proto.RegisterType((*RedactionOptions)(nil), "px.carnot.planner.distributedpb.RedactionOptions")
	proto.RegisterType((*OTelEndpointConfig)(nil), "px.carnot.planner.distributedpb.OTelEndpointConfig")
	proto.RegisterMapType((map[string]string)(nil), "px.carnot.planner.distributedpb.OTelEndpointConfig.HeadersEntry")
	proto.RegisterType((*PluginConfig)(nil), "px.carnot.planner.distributedpb.PluginConfig")
	proto.RegisterType((*DebugInfo)(nil), "px.carnot.planner.distributedpb.DebugInfo")
	proto.RegisterType((*DebugInfo_OTelDebugAttribute)(nil), "px.carnot.planner.distributedpb.DebugInfo.OTelDebugAttribute")
	proto.RegisterType((*LogicalPlannerState)(nil), "px.carnot.planner.distributedpb.LogicalPlannerState")
	proto.RegisterType((*LogicalPlannerResult)(nil), "px.carnot.planner.distributedpb.LogicalPlannerResult")
}

func init() {
	proto.RegisterFile("src/carnot/planner/distributedpb/distributed_plan.proto", fileDescriptor_30dce4250507a2af)
}

var fileDescriptor_30dce4250507a2af = []byte{
	// 1564 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0xc7,
	0x15, 0xd7, 0x8a, 0x94, 0x48, 0x3e, 0x92, 0x12, 0x3d, 0xa2, 0x5c, 0x96, 0x48, 0x48, 0x97, 0x48,
	0x50, 0xc1, 0x76, 0x96, 0xa9, 0x12, 0x34, 0x69, 0x80, 0xb4, 0x11, 0x45, 0xff, 0x61, 0xac, 0x26,
	0xea, 0x50, 0x06, 0x02, 0x1f, 0xba, 0x98, 0xe5, 0x0e, 0xc9, 0x45, 0x96, 0xbb, 0xab, 0x9d, 0x59,
	0x43, 0x6a, 0x51, 0xa0, 0x3d, 0xf6, 0xd4, 0x7e, 0x8c, 0x9e, 0x7a, 0xeb, 0xb5, 0xd7, 0xf6, 0xe8,
	0x63, 0x4e, 0x42, 0x4c, 0x5f, 0x7a, 0xcc, 0x17, 0x28, 0x50, 0xcc, 0x9b, 0x5d, 0x6a, 0x49, 0x13,
	0x90, 0xd3, 0x5c, 0xc8, 0x99, 0xf7, 0x7e, 0xef, 0xcf, 0xcc, 0x7b, 0xbf, 0x99, 0x59, 0xf8, 0x48,
	0x44, 0xa3, 0xee, 0x88, 0x45, 0x7e, 0x20, 0xbb, 0xa1, 0xc7, 0x7c, 0x9f, 0x47, 0x5d, 0xc7, 0x15,
	0x32, 0x72, 0xed, 0x58, 0x72, 0x27, 0xb4, 0xb3, 0x33, 0x4b, 0x21, 0xcc, 0x30, 0x0a, 0x64, 0x40,
	0xda, 0xe1, 0x85, 0xa9, 0xed, 0xcc, 0xc4, 0xce, 0x5c, 0xb2, 0x6b, 0xbe, 0x37, 0x71, 0xe5, 0x34,
	0xb6, 0xcd, 0x51, 0x30, 0xeb, 0x4e, 0x82, 0x49, 0xd0, 0x45, 0x3b, 0x3b, 0x1e, 0xe3, 0x0c, 0x27,
	0x38, 0xd2, 0xfe, 0x9a, 0x6d, 0x95, 0x08, 0x0b, 0x5d, 0x0d, 0xeb, 0xc6, 0xb1, 0xab, 0x82, 0xab,
	0xbf, 0x04, 0xf0, 0xd6, 0x4a, 0xa6, 0xa1, 0xdd, 0xbd, 0x4e, 0xa7, 0xf9, 0x2e, 0x6a, 0x83, 0xd9,
	0x2c, 0xf0, 0xbb, 0x36, 0x13, 0xbc, 0x2b, 0x24, 0x93, 0xb1, 0x08, 0xed, 0x64, 0x90, 0xc0, 0xee,
	0x2a, 0x98, 0x98, 0xb2, 0x88, 0x3b, 0x5d, 0xdb, 0x0b, 0x82, 0xd9, 0xd8, 0xf5, 0x24, 0x8f, 0x42,
	0x3b, 0x3b, 0x4b, 0xb0, 0xef, 0x64, 0xb0, 0x33, 0x2e, 0x99, 0xc3, 0x24, 0x0b, 0xed, 0xc5, 0x30,
	0x1b, 0x58, 0x32, 0xdb, 0xe3, 0x96, 0x90, 0x41, 0xc4, 0xbb, 0x62, 0x34, 0xe5, 0x33, 0x05, 0xd4,
	0x03, 0x0d, 0xeb, 0xcc, 0x0d, 0xa8, 0xfc, 0x3a, 0xb1, 0x1c, 0xf8, 0xe3, 0x80, 0x3c, 0x81, 0xdd,
	0xd4, 0x93, 0x35, 0x76, 0xb9, 0xe7, 0x88, 0x86, 0x71, 0x27, 0x77, 0xb0, 0x73, 0xd8, 0x31, 0xc3,
	0x0b, 0x53, 0x87, 0x35, 0xaf, 0xc3, 0x9a, 0xa9, 0xf1, 0xd9, 0x65, 0xc8, 0xe9, 0x4e, 0xaa, 0x78,
	0x88, 0x96, 0xe4, 0xf7, 0xb0, 0x7f, 0x71, 0x31, 0x65, 0x62, 0xfa, 0xf3, 0x0f, 0x2d, 0x5c, 0x88,
	0xa5, 0x57, 0xd2, 0xd8, 0xbc, 0x63, 0x1c, 0x94, 0x0f, 0xef, 0x67, 0x5c, 0x2e, 0xad, 0xda, 0xfc,
	0xea, 0xab, 0xc7, 0x68, 0xd5, 0x53, 0xd2, 0x87, 0x28, 0xed, 0xfd, 0x68, 0x7e, 0xd5, 0xde, 0x5b,
	0xa3, 0x78, 0xbc, 0x41, 0xf7, 0xd2, 0x28, 0x59, 0x7c, 0x11, 0xb6, 0xb5, 0xbf, 0xce, 0xb7, 0x79,
	0x80, 0x63, 0xac, 0x10, 0x2e, 0xf1, 0x7d, 0xa8, 0x9f, 0xc7, 0x3c, 0xba, 0xb4, 0xec, 0x28, 0xf8,
	0x9a, 0x47, 0x16, 0x73, 0x9c, 0x88, 0x0b, 0xb5, 0x4e, 0xe3, 0xa0, 0x44, 0x09, 0xea, 0x7a, 0xa8,
	0x3a, 0xd2, 0x1a, 0xf2, 0x11, 0x14, 0xd9, 0x84, 0xfb, 0xd2, 0x72, 0x9d, 0x06, 0x60, 0xea, 0xbb,
	0x2a, 0x75, 0xdd, 0x0c, 0xe6, 0xd3, 0xa7, 0x83, 0x7e, 0xaf, 0x3c, 0xbf, 0x6a, 0x17, 0x8e, 0x14,
	0x68, 0xd0, 0xa7, 0x05, 0x44, 0x0f, 0x1c, 0xf2, 0x0b, 0xd8, 0x9d, 0x32, 0x61, 0x4d, 0xa2, 0x70,
	0x64, 0x09, 0x1e, 0x3d, 0x4f, 0x96, 0x5e, 0xec, 0xdd, 0x9a, 0x5f, 0xb5, 0xab, 0x8f, 0x99, 0x78,
	0x44, 0x4f, 0x8f, 0x87, 0xa8, 0xa0, 0xd5, 0x29, 0x13, 0x8f, 0xa2, 0x70, 0xa4, 0xa7, 0xe4, 0x10,
	0x2a, 0x68, 0x96, 0x66, 0x97, 0x53, 0xd9, 0xf5, 0x76, 0xe7, 0x57, 0xed, 0xb2, 0x32, 0x4a, 0x52,
	0xa3, 0x65, 0x05, 0x4a, 0xf3, 0x7c, 0x07, 0x76, 0x54, 0x38, 0x2c, 0x1e, 0x56, 0xbd, 0x91, 0x57,
	0xd1, 0x68, 0x65, 0xca, 0x44, 0x9f, 0x49, 0x36, 0x54, 0x32, 0xf2, 0x2e, 0xec, 0x84, 0x51, 0x30,
	0xe2, 0x42, 0x70, 0x8d, 0x6d, 0x6c, 0x21, 0xaa, 0xba, 0x90, 0x2a, 0x2c, 0xf9, 0x10, 0x6e, 0xb3,
	0xd1, 0x88, 0x87, 0x52, 0x58, 0x11, 0x9f, 0x05, 0x92, 0x5b, 0x22, 0x88, 0xa3, 0x11, 0x17, 0x8d,
	0x6d, 0x84, 0xd7, 0x13, 0x2d, 0x45, 0xe5, 0x50, 0xeb, 0xc8, 0x00, 0x40, 0x77, 0x9d, 0xeb, 0x8f,
	0x83, 0x46, 0xe1, 0x4e, 0xee, 0xa0, 0x7c, 0x78, 0xd7, 0xbc, 0x81, 0x94, 0xe6, 0x99, 0x32, 0x51,
	0xc5, 0xa1, 0x25, 0x99, 0x0e, 0xc9, 0x5b, 0x90, 0x67, 0xc2, 0x75, 0x1a, 0xc5, 0x3b, 0xc6, 0x41,
	0xb5, 0x57, 0x9c, 0x5f, 0xb5, 0xf3, 0x47, 0xc3, 0x41, 0x9f, 0xa2, 0x94, 0x50, 0xa8, 0x2e, 0x1a,
	0x15, 0x63, 0x95, 0xb0, 0x30, 0xef, 0xdd, 0x18, 0x2b, 0xdb, 0xee, 0xb4, 0x32, 0xcb, 0x36, 0xff,
	0xc7, 0xb0, 0x23, 0x84, 0x67, 0x49, 0x16, 0x4d, 0xb8, 0xf4, 0xd9, 0x8c, 0x37, 0xca, 0xb8, 0xeb,
	0x58, 0xad, 0xe1, 0xf0, 0xe4, 0x0c, 0x15, 0x5f, 0xb0, 0x19, 0xa7, 0x55, 0x21, 0xbc, 0xb3, 0x05,
	0xae, 0x33, 0x85, 0xd2, 0x62, 0x0d, 0xa4, 0x0e, 0x5b, 0xb8, 0x8a, 0xa4, 0xa3, 0xf4, 0x84, 0xdc,
	0x83, 0x5b, 0x38, 0x90, 0xee, 0xef, 0x98, 0x74, 0x03, 0xdf, 0xfa, 0x9a, 0x5f, 0x62, 0x37, 0x94,
	0x68, 0x6d, 0x49, 0xf1, 0x84, 0x5f, 0x92, 0x06, 0x14, 0xb4, 0x4c, 0x15, 0x3e, 0x77, 0x50, 0xa2,
	0xe9, 0xb4, 0xf3, 0x17, 0x03, 0x60, 0x88, 0x14, 0xc6, 0x58, 0x04, 0xf2, 0x98, 0xa8, 0x0e, 0x85,
	0x63, 0xf2, 0x29, 0x14, 0x23, 0xee, 0xa1, 0xaf, 0x84, 0x69, 0x3f, 0x51, 0xbb, 0x92, 0x39, 0x0d,
	0xcc, 0xf4, 0x34, 0x30, 0x69, 0x02, 0xa4, 0x0b, 0x13, 0x62, 0x02, 0xe8, 0x6e, 0xf7, 0x5c, 0x21,
	0x31, 0xfc, 0xeb, 0xfd, 0x4e, 0x4b, 0x08, 0x39, 0x71, 0x85, 0xec, 0xfc, 0xdd, 0x80, 0x5a, 0xff,
	0x7a, 0x8b, 0x87, 0x92, 0x49, 0x4e, 0x4e, 0xa0, 0xac, 0xab, 0xa0, 0x8b, 0x63, 0xa0, 0x97, 0x7b,
	0x37, 0x16, 0xe7, 0x9a, 0xa6, 0x14, 0x46, 0xd7, 0x94, 0x3d, 0x81, 0xb2, 0xce, 0x58, 0x7b, 0xdb,
	0x7c, 0x43, 0x6f, 0xd7, 0xfb, 0x44, 0x41, 0x2c, 0xc6, 0x9d, 0x7f, 0xe5, 0x60, 0x37, 0x93, 0xf0,
	0xa9, 0xc7, 0x7c, 0x12, 0x01, 0x39, 0xb7, 0x53, 0xb2, 0x59, 0x32, 0xc0, 0x3b, 0x25, 0x49, 0xfb,
	0xc1, 0x8d, 0x81, 0x56, 0xbc, 0x99, 0xbf, 0xb1, 0x13, 0x4a, 0x9e, 0x05, 0x6a, 0xfe, 0xc0, 0x97,
	0xd1, 0x25, 0xdd, 0x3d, 0x5f, 0x96, 0x92, 0xe7, 0x50, 0x5f, 0x8e, 0xe9, 0xb0, 0x89, 0x3a, 0x62,
	0xf4, 0xf2, 0x1e, 0xfe, 0x90, 0xa8, 0x7d, 0x36, 0x19, 0x38, 0x3a, 0x6c, 0xed, 0x7c, 0x45, 0x4c,
	0x7e, 0x0a, 0x39, 0x87, 0x4d, 0xf0, 0x44, 0x29, 0x1f, 0xee, 0xaf, 0x84, 0x51, 0x7e, 0x8f, 0x1e,
	0x51, 0x85, 0x68, 0x3e, 0x83, 0xfa, 0xba, 0x95, 0x90, 0x1a, 0xe4, 0x54, 0xf3, 0xea, 0x9e, 0x53,
	0x43, 0x72, 0x1f, 0xb6, 0x9e, 0x33, 0x2f, 0xe6, 0x49, 0xbf, 0xdd, 0x7e, 0xdd, 0xa9, 0xb2, 0xa6,
	0x1a, 0xf4, 0xc9, 0xe6, 0xc7, 0x46, 0xf3, 0x18, 0xf6, 0xd7, 0xe6, 0xbb, 0xc6, 0x79, 0x3d, 0xeb,
	0x3c, 0x9f, 0x71, 0xd2, 0xf9, 0x93, 0x01, 0x35, 0xca, 0x1d, 0x36, 0x52, 0x8d, 0xfb, 0x65, 0xa8,
	0x7e, 0x05, 0xb9, 0x0f, 0x24, 0x16, 0xdc, 0x1a, 0xc7, 0x9e, 0x67, 0x45, 0xa9, 0x12, 0xfd, 0x15,
	0x69, 0x2d, 0x16, 0xfc, 0x61, 0xec, 0x79, 0x0b, 0x23, 0xf2, 0x2b, 0x78, 0x5b, 0xa1, 0xc3, 0x8b,
	0x04, 0x6b, 0x85, 0xae, 0x6b, 0xd9, 0x5c, 0x48, 0x8b, 0x8f, 0xc7, 0x41, 0x24, 0xf5, 0x81, 0x4d,
	0x1b, 0xb1, 0xe0, 0xa7, 0x17, 0xda, 0xec, 0xd4, 0x75, 0x7b, 0x5c, 0xc8, 0x07, 0xa8, 0xef, 0xfc,
	0xd7, 0x00, 0xf2, 0xe5, 0x19, 0xf7, 0x1e, 0xf8, 0x4e, 0x18, 0xb8, 0xbe, 0x3c, 0x0e, 0xfc, 0xb1,
	0x3b, 0x21, 0x3f, 0x86, 0x5c, 0x1c, 0x79, 0x7a, 0x19, 0xbd, 0xc2, 0xfc, 0xaa, 0x9d, 0x7b, 0x4a,
	0x4f, 0xa8, 0x92, 0x91, 0x67, 0x50, 0x98, 0x72, 0xe6, 0xf0, 0x48, 0x24, 0xa5, 0xfe, 0xec, 0xc6,
	0x52, 0xbf, 0x1e, 0xc0, 0x7c, 0xac, 0x5d, 0xe8, 0x22, 0xa7, 0x0e, 0x49, 0x13, 0x8a, 0xae, 0x2f,
	0xf8, 0x28, 0x8e, 0x38, 0x16, 0xb8, 0x48, 0x17, 0x73, 0x3c, 0x54, 0xdc, 0x19, 0x0f, 0x62, 0x89,
	0xf7, 0x42, 0x8e, 0xa6, 0xd3, 0xe6, 0x27, 0x50, 0xc9, 0xba, 0xbb, 0xa9, 0x06, 0xa5, 0x6c, 0x0d,
	0x28, 0x54, 0x4e, 0xbd, 0x78, 0xe2, 0xfa, 0xc9, 0xc2, 0x3b, 0x50, 0x15, 0x92, 0x45, 0xd2, 0x52,
	0xce, 0x2d, 0x5f, 0xdf, 0xab, 0x39, 0x5a, 0x46, 0xe1, 0x99, 0x3b, 0xe3, 0x5f, 0x08, 0xd2, 0x82,
	0x32, 0xf7, 0x9d, 0x05, 0x62, 0x13, 0x11, 0x25, 0xee, 0x3b, 0x5a, 0xdf, 0xf9, 0xa7, 0x01, 0xa5,
	0x3e, 0xb7, 0xe3, 0x09, 0xb2, 0xff, 0x1c, 0xf6, 0x03, 0xc9, 0x3d, 0xcb, 0x51, 0x12, 0x8b, 0xc9,
	0x64, 0x5f, 0x44, 0x42, 0xcf, 0x4f, 0x6f, 0x26, 0x4a, 0xea, 0x0a, 0xf7, 0x11, 0x67, 0x47, 0xa9,
	0x17, 0xba, 0xa7, 0x7c, 0x2f, 0xcb, 0x44, 0xf3, 0x97, 0xba, 0xa6, 0xcb, 0xe2, 0xb5, 0x87, 0xed,
	0xda, 0x8d, 0xe9, 0xfc, 0x63, 0x0b, 0xf6, 0x4e, 0x82, 0x89, 0x3b, 0x62, 0xde, 0xa9, 0x4e, 0x49,
	0x1f, 0x8b, 0xbf, 0x85, 0x5b, 0xd9, 0x87, 0xab, 0x7a, 0x04, 0xa6, 0x9c, 0xf9, 0xd9, 0xf7, 0xe1,
	0x3b, 0x7a, 0xa3, 0x35, 0x67, 0xf5, 0xd8, 0xfd, 0x0c, 0x2a, 0xca, 0xd6, 0x0a, 0x34, 0x17, 0x12,
	0x8e, 0xbf, 0xbd, 0x9e, 0x8e, 0x09, 0x61, 0x68, 0x39, 0xbc, 0x9e, 0xa8, 0xd7, 0x41, 0xc4, 0x45,
	0xec, 0xc9, 0xc5, 0xcb, 0x23, 0x8f, 0x0b, 0xab, 0x6a, 0x69, 0xfa, 0xd4, 0x78, 0x02, 0xfb, 0x09,
	0x6c, 0xe5, 0xc6, 0xdc, 0xc2, 0x86, 0xc7, 0xc7, 0x1a, 0x45, 0xc0, 0xf2, 0xbd, 0xb9, 0xa7, 0xad,
	0x86, 0xd9, 0xdb, 0x53, 0xed, 0xca, 0x82, 0xa8, 0x8b, 0xd4, 0x0b, 0x6f, 0xb8, 0x2b, 0xab, 0xfc,
	0xa7, 0xb5, 0x68, 0xf5, 0x44, 0xf8, 0x03, 0xd4, 0xb1, 0x81, 0x78, 0xc2, 0x20, 0x6b, 0x84, 0xad,
	0x8a, 0x2f, 0x8b, 0xf2, 0xe1, 0x07, 0xff, 0x07, 0xfb, 0x7a, 0xb7, 0xe7, 0x57, 0xed, 0x35, 0xb4,
	0xa7, 0x44, 0x05, 0x5a, 0x39, 0x0a, 0x28, 0x54, 0x43, 0x64, 0x48, 0x1a, 0xf7, 0x4d, 0x9f, 0x2a,
	0x59, 0x5e, 0xd1, 0x4a, 0x98, 0x65, 0xd9, 0x00, 0x40, 0xd3, 0x01, 0x2f, 0x44, 0xfd, 0x28, 0xbd,
	0xfb, 0xe6, 0x44, 0xa0, 0x25, 0x27, 0x1d, 0x7e, 0x9e, 0x2f, 0x1a, 0xb5, 0xcd, 0xcf, 0xf3, 0xc5,
	0xed, 0x5a, 0xa1, 0xf3, 0x67, 0x03, 0xea, 0xcb, 0x7d, 0xab, 0x8b, 0x48, 0xee, 0xc1, 0xb6, 0xfe,
	0x62, 0xc1, 0xe6, 0x2f, 0x1f, 0xee, 0xe1, 0xdb, 0x3d, 0xf9, 0x98, 0x31, 0x87, 0x38, 0xa0, 0x09,
	0x84, 0xf4, 0x21, 0x8f, 0xd7, 0xa7, 0x6e, 0xec, 0xf7, 0xbf, 0xef, 0x45, 0x46, 0xd1, 0xba, 0x77,
	0xfc, 0xe2, 0x65, 0x6b, 0xe3, 0x9b, 0x97, 0xad, 0x8d, 0xef, 0x5e, 0xb6, 0x8c, 0x3f, 0xce, 0x5b,
	0xc6, 0xdf, 0xe6, 0x2d, 0xe3, 0xdf, 0xf3, 0x96, 0xf1, 0x62, 0xde, 0x32, 0xbe, 0x9d, 0xb7, 0x8c,
	0xff, 0xcc, 0x5b, 0x1b, 0xdf, 0xcd, 0x5b, 0xc6, 0x5f, 0x5f, 0xb5, 0x36, 0x5e, 0xbc, 0x6a, 0x6d,
	0x7c, 0xf3, 0xaa, 0xb5, 0xf1, 0xac, 0xba, 0xe4, 0xda, 0xde, 0xc6, 0xef, 0x9c, 0x0f, 0xfe, 0x17,
	0x00, 0x00, 0xff, 0xff, 0xb9, 0x38, 0x96, 0xde, 0x51, 0x0e, 0x00, 0x00,
}

func (this *MetadataInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataInfo)
	if !ok {
		that2, ok := that.(MetadataInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.MetadataFields) != len(that1.MetadataFields) {
		return false
	}
	for i := range this.MetadataFields {
		if this.MetadataFields[i] != that1.MetadataFields[i] {
			return false
		}
	}
	if that1.Filter == nil {
		if this.Filter != nil {
			return false
		}
	} else if this.Filter == nil {
		return false
	} else if !this.Filter.Equal(that1.Filter) {
		return false
	}
	return true
}
func (this *MetadataInfo_XXHash64BloomFilter) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MetadataInfo_XXHash64BloomFilter)
	if !ok {
		that2, ok := that.(MetadataInfo_XXHash64BloomFilter)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.XXHash64BloomFilter.Equal(that1.XXHash64BloomFilter) {
		return false
	}
	return true
}
func (this *CarnotInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CarnotInfo)
	if !ok {
		that2, ok := that.(CarnotInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.QueryBrokerAddress != that1.QueryBrokerAddress {
		return false
	}
	if !this.AgentID.Equal(that1.AgentID) {
		return false
	}
	if this.HasGRPCServer != that1.HasGRPCServer {
		return false
	}
	if this.GRPCAddress != that1.GRPCAddress {
		return false
	}
	if this.HasDataStore != that1.HasDataStore {
		return false
	}
	if this.ProcessesData != that1.ProcessesData {
		return false
	}
	if this.AcceptsRemoteSources != that1.AcceptsRemoteSources {
		return false
	}
	if len(this.TableInfo) != len(that1.TableInfo) {
		return false
	}
	for i := range this.TableInfo {
		if !this.TableInfo[i].Equal(that1.TableInfo[i]) {
			return false
		}
	}
	if this.ASID != that1.ASID {
		return false
	}
	if !this.MetadataInfo.Equal(that1.MetadataInfo) {
		return false
	}
	if this.SSLTargetName != that1.SSLTargetName {
		return false
	}
	return true
}
func (this *TableInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TableInfo)
	if !ok {
		that2, ok := that.(TableInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Table != that1.Table {
		return false
	}
	if this.TabletizationKey != that1.TabletizationKey {
		return false
	}
	if len(this.Tablets) != len(that1.Tablets) {
		return false
	}
	for i := range this.Tablets {
		if this.Tablets[i] != that1.Tablets[i] {
			return false
		}
	}
	return true
}
func (this *SchemaInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SchemaInfo)
	if !ok {
		that2, ok := that.(SchemaInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if !this.Relation.Equal(that1.Relation) {
		return false
	}
	if len(this.AgentList) != len(that1.AgentList) {
		return false
	}
	for i := range this.AgentList {
		if !this.AgentList[i].Equal(that1.AgentList[i]) {
			return false
		}
	}
	return true
}
func (this *DistributedState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DistributedState)
	if !ok {
		that2, ok := that.(DistributedState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.CarnotInfo) != len(that1.CarnotInfo) {
		return false
	}
	for i := range this.CarnotInfo {
		if !this.CarnotInfo[i].Equal(that1.CarnotInfo[i]) {
			return false
		}
	}
	if len(this.SchemaInfo) != len(that1.SchemaInfo) {
		return false
	}
	for i := range this.SchemaInfo {
		if !this.SchemaInfo[i].Equal(that1.SchemaInfo[i]) {
			return false
		}
	}
	return true
}
func (this *DistributedPlan) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DistributedPlan)
	if !ok {
		that2, ok := that.(DistributedPlan)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.QbAddressToPlan) != len(that1.QbAddressToPlan) {
		return false
	}
	for i := range this.QbAddressToPlan {
		if !this.QbAddressToPlan[i].Equal(that1.QbAddressToPlan[i]) {
			return false
		}
	}
	if len(this.QbAddressToDagId) != len(that1.QbAddressToDagId) {
		return false
	}
	for i := range this.QbAddressToDagId {
		if this.QbAddressToDagId[i] != that1.QbAddressToDagId[i] {
			return false
		}
	}
	if !this.Dag.Equal(that1.Dag) {
		return false
	}
	return true
}
func (this *RedactionOptions) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RedactionOptions)
	if !ok {
		that2, ok := that.(RedactionOptions)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.UseFullRedaction != that1.UseFullRedaction {
		return false
	}
	if this.UsePxRedactPiiBestEffort != that1.UsePxRedactPiiBestEffort {
		return false
	}
	return true
}
func (this *OTelEndpointConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OTelEndpointConfig)
	if !ok {
		that2, ok := that.(OTelEndpointConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.URL != that1.URL {
		return false
	}
	if len(this.Headers) != len(that1.Headers) {
		return false
	}
	for i := range this.Headers {
		if this.Headers[i] != that1.Headers[i] {
			return false
		}
	}
	if this.Insecure != that1.Insecure {
		return false
	}
	if this.Timeout != that1.Timeout {
		return false
	}
	return true
}
func (this *PluginConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PluginConfig)
	if !ok {
		that2, ok := that.(PluginConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.StartTimeNs != that1.StartTimeNs {
		return false
	}
	if this.EndTimeNs != that1.EndTimeNs {
		return false
	}
	return true
}
func (this *DebugInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugInfo)
	if !ok {
		that2, ok := that.(DebugInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.OtelDebugAttributes) != len(that1.OtelDebugAttributes) {
		return false
	}
	for i := range this.OtelDebugAttributes {
		if !this.OtelDebugAttributes[i].Equal(that1.OtelDebugAttributes[i]) {
			return false
		}
	}
	return true
}
func (this *DebugInfo_OTelDebugAttribute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DebugInfo_OTelDebugAttribute)
	if !ok {
		that2, ok := that.(DebugInfo_OTelDebugAttribute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *LogicalPlannerState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogicalPlannerState)
	if !ok {
		that2, ok := that.(LogicalPlannerState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DistributedState.Equal(that1.DistributedState) {
		return false
	}
	if !this.PlanOptions.Equal(that1.PlanOptions) {
		return false
	}
	if this.ResultAddress != that1.ResultAddress {
		return false
	}
	if this.ResultSSLTargetName != that1.ResultSSLTargetName {
		return false
	}
	if !this.RedactionOptions.Equal(that1.RedactionOptions) {
		return false
	}
	if !this.OTelEndpointConfig.Equal(that1.OTelEndpointConfig) {
		return false
	}
	if !this.PluginConfig.Equal(that1.PluginConfig) {
		return false
	}
	if !this.DebugInfo.Equal(that1.DebugInfo) {
		return false
	}
	return true
}
func (this *LogicalPlannerResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogicalPlannerResult)
	if !ok {
		that2, ok := that.(LogicalPlannerResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	if !this.Plan.Equal(that1.Plan) {
		return false
	}
	return true
}
func (this *MetadataInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.MetadataInfo{")
	s = append(s, "MetadataFields: "+fmt.Sprintf("%#v", this.MetadataFields)+",\n")
	if this.Filter != nil {
		s = append(s, "Filter: "+fmt.Sprintf("%#v", this.Filter)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MetadataInfo_XXHash64BloomFilter) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&distributedpb.MetadataInfo_XXHash64BloomFilter{` +
		`XXHash64BloomFilter:` + fmt.Sprintf("%#v", this.XXHash64BloomFilter) + `}`}, ", ")
	return s
}
func (this *CarnotInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&distributedpb.CarnotInfo{")
	s = append(s, "QueryBrokerAddress: "+fmt.Sprintf("%#v", this.QueryBrokerAddress)+",\n")
	if this.AgentID != nil {
		s = append(s, "AgentID: "+fmt.Sprintf("%#v", this.AgentID)+",\n")
	}
	s = append(s, "HasGRPCServer: "+fmt.Sprintf("%#v", this.HasGRPCServer)+",\n")
	s = append(s, "GRPCAddress: "+fmt.Sprintf("%#v", this.GRPCAddress)+",\n")
	s = append(s, "HasDataStore: "+fmt.Sprintf("%#v", this.HasDataStore)+",\n")
	s = append(s, "ProcessesData: "+fmt.Sprintf("%#v", this.ProcessesData)+",\n")
	s = append(s, "AcceptsRemoteSources: "+fmt.Sprintf("%#v", this.AcceptsRemoteSources)+",\n")
	if this.TableInfo != nil {
		s = append(s, "TableInfo: "+fmt.Sprintf("%#v", this.TableInfo)+",\n")
	}
	s = append(s, "ASID: "+fmt.Sprintf("%#v", this.ASID)+",\n")
	if this.MetadataInfo != nil {
		s = append(s, "MetadataInfo: "+fmt.Sprintf("%#v", this.MetadataInfo)+",\n")
	}
	s = append(s, "SSLTargetName: "+fmt.Sprintf("%#v", this.SSLTargetName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TableInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&distributedpb.TableInfo{")
	s = append(s, "Table: "+fmt.Sprintf("%#v", this.Table)+",\n")
	s = append(s, "TabletizationKey: "+fmt.Sprintf("%#v", this.TabletizationKey)+",\n")
	s = append(s, "Tablets: "+fmt.Sprintf("%#v", this.Tablets)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SchemaInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&distributedpb.SchemaInfo{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	if this.Relation != nil {
		s = append(s, "Relation: "+fmt.Sprintf("%#v", this.Relation)+",\n")
	}
	if this.AgentList != nil {
		s = append(s, "AgentList: "+fmt.Sprintf("%#v", this.AgentList)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DistributedState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.DistributedState{")
	if this.CarnotInfo != nil {
		s = append(s, "CarnotInfo: "+fmt.Sprintf("%#v", this.CarnotInfo)+",\n")
	}
	if this.SchemaInfo != nil {
		s = append(s, "SchemaInfo: "+fmt.Sprintf("%#v", this.SchemaInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DistributedPlan) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&distributedpb.DistributedPlan{")
	keysForQbAddressToPlan := make([]string, 0, len(this.QbAddressToPlan))
	for k, _ := range this.QbAddressToPlan {
		keysForQbAddressToPlan = append(keysForQbAddressToPlan, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForQbAddressToPlan)
	mapStringForQbAddressToPlan := "map[string]*planpb.Plan{"
	for _, k := range keysForQbAddressToPlan {
		mapStringForQbAddressToPlan += fmt.Sprintf("%#v: %#v,", k, this.QbAddressToPlan[k])
	}
	mapStringForQbAddressToPlan += "}"
	if this.QbAddressToPlan != nil {
		s = append(s, "QbAddressToPlan: "+mapStringForQbAddressToPlan+",\n")
	}
	keysForQbAddressToDagId := make([]string, 0, len(this.QbAddressToDagId))
	for k, _ := range this.QbAddressToDagId {
		keysForQbAddressToDagId = append(keysForQbAddressToDagId, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForQbAddressToDagId)
	mapStringForQbAddressToDagId := "map[string]uint64{"
	for _, k := range keysForQbAddressToDagId {
		mapStringForQbAddressToDagId += fmt.Sprintf("%#v: %#v,", k, this.QbAddressToDagId[k])
	}
	mapStringForQbAddressToDagId += "}"
	if this.QbAddressToDagId != nil {
		s = append(s, "QbAddressToDagId: "+mapStringForQbAddressToDagId+",\n")
	}
	if this.Dag != nil {
		s = append(s, "Dag: "+fmt.Sprintf("%#v", this.Dag)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RedactionOptions) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.RedactionOptions{")
	s = append(s, "UseFullRedaction: "+fmt.Sprintf("%#v", this.UseFullRedaction)+",\n")
	s = append(s, "UsePxRedactPiiBestEffort: "+fmt.Sprintf("%#v", this.UsePxRedactPiiBestEffort)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OTelEndpointConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&distributedpb.OTelEndpointConfig{")
	s = append(s, "URL: "+fmt.Sprintf("%#v", this.URL)+",\n")
	keysForHeaders := make([]string, 0, len(this.Headers))
	for k, _ := range this.Headers {
		keysForHeaders = append(keysForHeaders, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
	mapStringForHeaders := "map[string]string{"
	for _, k := range keysForHeaders {
		mapStringForHeaders += fmt.Sprintf("%#v: %#v,", k, this.Headers[k])
	}
	mapStringForHeaders += "}"
	if this.Headers != nil {
		s = append(s, "Headers: "+mapStringForHeaders+",\n")
	}
	s = append(s, "Insecure: "+fmt.Sprintf("%#v", this.Insecure)+",\n")
	s = append(s, "Timeout: "+fmt.Sprintf("%#v", this.Timeout)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *PluginConfig) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.PluginConfig{")
	s = append(s, "StartTimeNs: "+fmt.Sprintf("%#v", this.StartTimeNs)+",\n")
	s = append(s, "EndTimeNs: "+fmt.Sprintf("%#v", this.EndTimeNs)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&distributedpb.DebugInfo{")
	if this.OtelDebugAttributes != nil {
		s = append(s, "OtelDebugAttributes: "+fmt.Sprintf("%#v", this.OtelDebugAttributes)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DebugInfo_OTelDebugAttribute) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.DebugInfo_OTelDebugAttribute{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LogicalPlannerState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 12)
	s = append(s, "&distributedpb.LogicalPlannerState{")
	if this.DistributedState != nil {
		s = append(s, "DistributedState: "+fmt.Sprintf("%#v", this.DistributedState)+",\n")
	}
	if this.PlanOptions != nil {
		s = append(s, "PlanOptions: "+fmt.Sprintf("%#v", this.PlanOptions)+",\n")
	}
	s = append(s, "ResultAddress: "+fmt.Sprintf("%#v", this.ResultAddress)+",\n")
	s = append(s, "ResultSSLTargetName: "+fmt.Sprintf("%#v", this.ResultSSLTargetName)+",\n")
	if this.RedactionOptions != nil {
		s = append(s, "RedactionOptions: "+fmt.Sprintf("%#v", this.RedactionOptions)+",\n")
	}
	if this.OTelEndpointConfig != nil {
		s = append(s, "OTelEndpointConfig: "+fmt.Sprintf("%#v", this.OTelEndpointConfig)+",\n")
	}
	if this.PluginConfig != nil {
		s = append(s, "PluginConfig: "+fmt.Sprintf("%#v", this.PluginConfig)+",\n")
	}
	if this.DebugInfo != nil {
		s = append(s, "DebugInfo: "+fmt.Sprintf("%#v", this.DebugInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LogicalPlannerResult) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&distributedpb.LogicalPlannerResult{")
	if this.Status != nil {
		s = append(s, "Status: "+fmt.Sprintf("%#v", this.Status)+",\n")
	}
	if this.Plan != nil {
		s = append(s, "Plan: "+fmt.Sprintf("%#v", this.Plan)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDistributedPlan(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *MetadataInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MetadataInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Filter != nil {
		{
			size := m.Filter.Size()
			i -= size
			if _, err := m.Filter.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.MetadataFields) > 0 {
		dAtA2 := make([]byte, len(m.MetadataFields)*10)
		var j1 int
		for _, num := range m.MetadataFields {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintDistributedPlan(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MetadataInfo_XXHash64BloomFilter) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MetadataInfo_XXHash64BloomFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.XXHash64BloomFilter != nil {
		{
			size, err := m.XXHash64BloomFilter.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *CarnotInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CarnotInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CarnotInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SSLTargetName) > 0 {
		i -= len(m.SSLTargetName)
		copy(dAtA[i:], m.SSLTargetName)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.SSLTargetName)))
		i--
		dAtA[i] = 0x5a
	}
	if m.AgentID != nil {
		{
			size, err := m.AgentID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.MetadataInfo != nil {
		{
			size, err := m.MetadataInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.ASID != 0 {
		i = encodeVarintDistributedPlan(dAtA, i, uint64(m.ASID))
		i--
		dAtA[i] = 0x40
	}
	if len(m.TableInfo) > 0 {
		for iNdEx := len(m.TableInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TableInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.AcceptsRemoteSources {
		i--
		if m.AcceptsRemoteSources {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.ProcessesData {
		i--
		if m.ProcessesData {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.HasDataStore {
		i--
		if m.HasDataStore {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.GRPCAddress) > 0 {
		i -= len(m.GRPCAddress)
		copy(dAtA[i:], m.GRPCAddress)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.GRPCAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if m.HasGRPCServer {
		i--
		if m.HasGRPCServer {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.QueryBrokerAddress) > 0 {
		i -= len(m.QueryBrokerAddress)
		copy(dAtA[i:], m.QueryBrokerAddress)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.QueryBrokerAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TableInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TableInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TableInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Tablets) > 0 {
		for iNdEx := len(m.Tablets) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Tablets[iNdEx])
			copy(dAtA[i:], m.Tablets[iNdEx])
			i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Tablets[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.TabletizationKey) > 0 {
		i -= len(m.TabletizationKey)
		copy(dAtA[i:], m.TabletizationKey)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.TabletizationKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Table) > 0 {
		i -= len(m.Table)
		copy(dAtA[i:], m.Table)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Table)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SchemaInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SchemaInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SchemaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AgentList) > 0 {
		for iNdEx := len(m.AgentList) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AgentList[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DistributedState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DistributedState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DistributedState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SchemaInfo) > 0 {
		for iNdEx := len(m.SchemaInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SchemaInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.CarnotInfo) > 0 {
		for iNdEx := len(m.CarnotInfo) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CarnotInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DistributedPlan) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DistributedPlan) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DistributedPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Dag != nil {
		{
			size, err := m.Dag.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.QbAddressToDagId) > 0 {
		for k := range m.QbAddressToDagId {
			v := m.QbAddressToDagId[k]
			baseI := i
			i = encodeVarintDistributedPlan(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDistributedPlan(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDistributedPlan(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.QbAddressToPlan) > 0 {
		for k := range m.QbAddressToPlan {
			v := m.QbAddressToPlan[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDistributedPlan(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDistributedPlan(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *RedactionOptions) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RedactionOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RedactionOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UsePxRedactPiiBestEffort {
		i--
		if m.UsePxRedactPiiBestEffort {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.UseFullRedaction {
		i--
		if m.UseFullRedaction {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *OTelEndpointConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OTelEndpointConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OTelEndpointConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Timeout != 0 {
		i = encodeVarintDistributedPlan(dAtA, i, uint64(m.Timeout))
		i--
		dAtA[i] = 0x20
	}
	if m.Insecure {
		i--
		if m.Insecure {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Headers) > 0 {
		for k := range m.Headers {
			v := m.Headers[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintDistributedPlan(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintDistributedPlan(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintDistributedPlan(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.URL) > 0 {
		i -= len(m.URL)
		copy(dAtA[i:], m.URL)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.URL)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PluginConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PluginConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PluginConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndTimeNs != 0 {
		i = encodeVarintDistributedPlan(dAtA, i, uint64(m.EndTimeNs))
		i--
		dAtA[i] = 0x10
	}
	if m.StartTimeNs != 0 {
		i = encodeVarintDistributedPlan(dAtA, i, uint64(m.StartTimeNs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DebugInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OtelDebugAttributes) > 0 {
		for iNdEx := len(m.OtelDebugAttributes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OtelDebugAttributes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DebugInfo_OTelDebugAttribute) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DebugInfo_OTelDebugAttribute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DebugInfo_OTelDebugAttribute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LogicalPlannerState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LogicalPlannerState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogicalPlannerState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DebugInfo != nil {
		{
			size, err := m.DebugInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.PluginConfig != nil {
		{
			size, err := m.PluginConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.OTelEndpointConfig != nil {
		{
			size, err := m.OTelEndpointConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.RedactionOptions != nil {
		{
			size, err := m.RedactionOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ResultSSLTargetName) > 0 {
		i -= len(m.ResultSSLTargetName)
		copy(dAtA[i:], m.ResultSSLTargetName)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.ResultSSLTargetName)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ResultAddress) > 0 {
		i -= len(m.ResultAddress)
		copy(dAtA[i:], m.ResultAddress)
		i = encodeVarintDistributedPlan(dAtA, i, uint64(len(m.ResultAddress)))
		i--
		dAtA[i] = 0x22
	}
	if m.PlanOptions != nil {
		{
			size, err := m.PlanOptions.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.DistributedState != nil {
		{
			size, err := m.DistributedState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *LogicalPlannerResult) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LogicalPlannerResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogicalPlannerResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Plan != nil {
		{
			size, err := m.Plan.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDistributedPlan(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintDistributedPlan(dAtA []byte, offset int, v uint64) int {
	offset -= sovDistributedPlan(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MetadataInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MetadataFields) > 0 {
		l = 0
		for _, e := range m.MetadataFields {
			l += sovDistributedPlan(uint64(e))
		}
		n += 1 + sovDistributedPlan(uint64(l)) + l
	}
	if m.Filter != nil {
		n += m.Filter.Size()
	}
	return n
}

func (m *MetadataInfo_XXHash64BloomFilter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXHash64BloomFilter != nil {
		l = m.XXHash64BloomFilter.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}
func (m *CarnotInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.QueryBrokerAddress)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.HasGRPCServer {
		n += 2
	}
	l = len(m.GRPCAddress)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.HasDataStore {
		n += 2
	}
	if m.ProcessesData {
		n += 2
	}
	if m.AcceptsRemoteSources {
		n += 2
	}
	if len(m.TableInfo) > 0 {
		for _, e := range m.TableInfo {
			l = e.Size()
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	if m.ASID != 0 {
		n += 1 + sovDistributedPlan(uint64(m.ASID))
	}
	if m.MetadataInfo != nil {
		l = m.MetadataInfo.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.AgentID != nil {
		l = m.AgentID.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	l = len(m.SSLTargetName)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}

func (m *TableInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Table)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	l = len(m.TabletizationKey)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if len(m.Tablets) > 0 {
		for _, s := range m.Tablets {
			l = len(s)
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	return n
}

func (m *SchemaInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if len(m.AgentList) > 0 {
		for _, e := range m.AgentList {
			l = e.Size()
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	return n
}

func (m *DistributedState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.CarnotInfo) > 0 {
		for _, e := range m.CarnotInfo {
			l = e.Size()
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	if len(m.SchemaInfo) > 0 {
		for _, e := range m.SchemaInfo {
			l = e.Size()
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	return n
}

func (m *DistributedPlan) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.QbAddressToPlan) > 0 {
		for k, v := range m.QbAddressToPlan {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovDistributedPlan(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovDistributedPlan(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovDistributedPlan(uint64(mapEntrySize))
		}
	}
	if len(m.QbAddressToDagId) > 0 {
		for k, v := range m.QbAddressToDagId {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovDistributedPlan(uint64(len(k))) + 1 + sovDistributedPlan(uint64(v))
			n += mapEntrySize + 1 + sovDistributedPlan(uint64(mapEntrySize))
		}
	}
	if m.Dag != nil {
		l = m.Dag.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}

func (m *RedactionOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UseFullRedaction {
		n += 2
	}
	if m.UsePxRedactPiiBestEffort {
		n += 2
	}
	return n
}

func (m *OTelEndpointConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.URL)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if len(m.Headers) > 0 {
		for k, v := range m.Headers {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovDistributedPlan(uint64(len(k))) + 1 + len(v) + sovDistributedPlan(uint64(len(v)))
			n += mapEntrySize + 1 + sovDistributedPlan(uint64(mapEntrySize))
		}
	}
	if m.Insecure {
		n += 2
	}
	if m.Timeout != 0 {
		n += 1 + sovDistributedPlan(uint64(m.Timeout))
	}
	return n
}

func (m *PluginConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StartTimeNs != 0 {
		n += 1 + sovDistributedPlan(uint64(m.StartTimeNs))
	}
	if m.EndTimeNs != 0 {
		n += 1 + sovDistributedPlan(uint64(m.EndTimeNs))
	}
	return n
}

func (m *DebugInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.OtelDebugAttributes) > 0 {
		for _, e := range m.OtelDebugAttributes {
			l = e.Size()
			n += 1 + l + sovDistributedPlan(uint64(l))
		}
	}
	return n
}

func (m *DebugInfo_OTelDebugAttribute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}

func (m *LogicalPlannerState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DistributedState != nil {
		l = m.DistributedState.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.PlanOptions != nil {
		l = m.PlanOptions.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	l = len(m.ResultAddress)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	l = len(m.ResultSSLTargetName)
	if l > 0 {
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.RedactionOptions != nil {
		l = m.RedactionOptions.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.OTelEndpointConfig != nil {
		l = m.OTelEndpointConfig.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.PluginConfig != nil {
		l = m.PluginConfig.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.DebugInfo != nil {
		l = m.DebugInfo.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}

func (m *LogicalPlannerResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	if m.Plan != nil {
		l = m.Plan.Size()
		n += 1 + l + sovDistributedPlan(uint64(l))
	}
	return n
}

func sovDistributedPlan(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDistributedPlan(x uint64) (n int) {
	return sovDistributedPlan(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *MetadataInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataInfo{`,
		`MetadataFields:` + fmt.Sprintf("%v", this.MetadataFields) + `,`,
		`Filter:` + fmt.Sprintf("%v", this.Filter) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MetadataInfo_XXHash64BloomFilter) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MetadataInfo_XXHash64BloomFilter{`,
		`XXHash64BloomFilter:` + strings.Replace(fmt.Sprintf("%v", this.XXHash64BloomFilter), "XXHash64BloomFilter", "bloomfilterpb.XXHash64BloomFilter", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CarnotInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTableInfo := "[]*TableInfo{"
	for _, f := range this.TableInfo {
		repeatedStringForTableInfo += strings.Replace(f.String(), "TableInfo", "TableInfo", 1) + ","
	}
	repeatedStringForTableInfo += "}"
	s := strings.Join([]string{`&CarnotInfo{`,
		`QueryBrokerAddress:` + fmt.Sprintf("%v", this.QueryBrokerAddress) + `,`,
		`HasGRPCServer:` + fmt.Sprintf("%v", this.HasGRPCServer) + `,`,
		`GRPCAddress:` + fmt.Sprintf("%v", this.GRPCAddress) + `,`,
		`HasDataStore:` + fmt.Sprintf("%v", this.HasDataStore) + `,`,
		`ProcessesData:` + fmt.Sprintf("%v", this.ProcessesData) + `,`,
		`AcceptsRemoteSources:` + fmt.Sprintf("%v", this.AcceptsRemoteSources) + `,`,
		`TableInfo:` + repeatedStringForTableInfo + `,`,
		`ASID:` + fmt.Sprintf("%v", this.ASID) + `,`,
		`MetadataInfo:` + strings.Replace(this.MetadataInfo.String(), "MetadataInfo", "MetadataInfo", 1) + `,`,
		`AgentID:` + strings.Replace(fmt.Sprintf("%v", this.AgentID), "UUID", "uuidpb.UUID", 1) + `,`,
		`SSLTargetName:` + fmt.Sprintf("%v", this.SSLTargetName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TableInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TableInfo{`,
		`Table:` + fmt.Sprintf("%v", this.Table) + `,`,
		`TabletizationKey:` + fmt.Sprintf("%v", this.TabletizationKey) + `,`,
		`Tablets:` + fmt.Sprintf("%v", this.Tablets) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SchemaInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForAgentList := "[]*UUID{"
	for _, f := range this.AgentList {
		repeatedStringForAgentList += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForAgentList += "}"
	s := strings.Join([]string{`&SchemaInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Relation:` + strings.Replace(fmt.Sprintf("%v", this.Relation), "Relation", "schemapb.Relation", 1) + `,`,
		`AgentList:` + repeatedStringForAgentList + `,`,
		`}`,
	}, "")
	return s
}
func (this *DistributedState) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForCarnotInfo := "[]*CarnotInfo{"
	for _, f := range this.CarnotInfo {
		repeatedStringForCarnotInfo += strings.Replace(f.String(), "CarnotInfo", "CarnotInfo", 1) + ","
	}
	repeatedStringForCarnotInfo += "}"
	repeatedStringForSchemaInfo := "[]*SchemaInfo{"
	for _, f := range this.SchemaInfo {
		repeatedStringForSchemaInfo += strings.Replace(f.String(), "SchemaInfo", "SchemaInfo", 1) + ","
	}
	repeatedStringForSchemaInfo += "}"
	s := strings.Join([]string{`&DistributedState{`,
		`CarnotInfo:` + repeatedStringForCarnotInfo + `,`,
		`SchemaInfo:` + repeatedStringForSchemaInfo + `,`,
		`}`,
	}, "")
	return s
}
func (this *DistributedPlan) String() string {
	if this == nil {
		return "nil"
	}
	keysForQbAddressToPlan := make([]string, 0, len(this.QbAddressToPlan))
	for k, _ := range this.QbAddressToPlan {
		keysForQbAddressToPlan = append(keysForQbAddressToPlan, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForQbAddressToPlan)
	mapStringForQbAddressToPlan := "map[string]*planpb.Plan{"
	for _, k := range keysForQbAddressToPlan {
		mapStringForQbAddressToPlan += fmt.Sprintf("%v: %v,", k, this.QbAddressToPlan[k])
	}
	mapStringForQbAddressToPlan += "}"
	keysForQbAddressToDagId := make([]string, 0, len(this.QbAddressToDagId))
	for k, _ := range this.QbAddressToDagId {
		keysForQbAddressToDagId = append(keysForQbAddressToDagId, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForQbAddressToDagId)
	mapStringForQbAddressToDagId := "map[string]uint64{"
	for _, k := range keysForQbAddressToDagId {
		mapStringForQbAddressToDagId += fmt.Sprintf("%v: %v,", k, this.QbAddressToDagId[k])
	}
	mapStringForQbAddressToDagId += "}"
	s := strings.Join([]string{`&DistributedPlan{`,
		`QbAddressToPlan:` + mapStringForQbAddressToPlan + `,`,
		`QbAddressToDagId:` + mapStringForQbAddressToDagId + `,`,
		`Dag:` + strings.Replace(fmt.Sprintf("%v", this.Dag), "DAG", "planpb.DAG", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RedactionOptions) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RedactionOptions{`,
		`UseFullRedaction:` + fmt.Sprintf("%v", this.UseFullRedaction) + `,`,
		`UsePxRedactPiiBestEffort:` + fmt.Sprintf("%v", this.UsePxRedactPiiBestEffort) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OTelEndpointConfig) String() string {
	if this == nil {
		return "nil"
	}
	keysForHeaders := make([]string, 0, len(this.Headers))
	for k, _ := range this.Headers {
		keysForHeaders = append(keysForHeaders, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForHeaders)
	mapStringForHeaders := "map[string]string{"
	for _, k := range keysForHeaders {
		mapStringForHeaders += fmt.Sprintf("%v: %v,", k, this.Headers[k])
	}
	mapStringForHeaders += "}"
	s := strings.Join([]string{`&OTelEndpointConfig{`,
		`URL:` + fmt.Sprintf("%v", this.URL) + `,`,
		`Headers:` + mapStringForHeaders + `,`,
		`Insecure:` + fmt.Sprintf("%v", this.Insecure) + `,`,
		`Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PluginConfig) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PluginConfig{`,
		`StartTimeNs:` + fmt.Sprintf("%v", this.StartTimeNs) + `,`,
		`EndTimeNs:` + fmt.Sprintf("%v", this.EndTimeNs) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForOtelDebugAttributes := "[]*DebugInfo_OTelDebugAttribute{"
	for _, f := range this.OtelDebugAttributes {
		repeatedStringForOtelDebugAttributes += strings.Replace(fmt.Sprintf("%v", f), "DebugInfo_OTelDebugAttribute", "DebugInfo_OTelDebugAttribute", 1) + ","
	}
	repeatedStringForOtelDebugAttributes += "}"
	s := strings.Join([]string{`&DebugInfo{`,
		`OtelDebugAttributes:` + repeatedStringForOtelDebugAttributes + `,`,
		`}`,
	}, "")
	return s
}
func (this *DebugInfo_OTelDebugAttribute) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DebugInfo_OTelDebugAttribute{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LogicalPlannerState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LogicalPlannerState{`,
		`DistributedState:` + strings.Replace(this.DistributedState.String(), "DistributedState", "DistributedState", 1) + `,`,
		`PlanOptions:` + strings.Replace(fmt.Sprintf("%v", this.PlanOptions), "PlanOptions", "planpb.PlanOptions", 1) + `,`,
		`ResultAddress:` + fmt.Sprintf("%v", this.ResultAddress) + `,`,
		`ResultSSLTargetName:` + fmt.Sprintf("%v", this.ResultSSLTargetName) + `,`,
		`RedactionOptions:` + strings.Replace(this.RedactionOptions.String(), "RedactionOptions", "RedactionOptions", 1) + `,`,
		`OTelEndpointConfig:` + strings.Replace(this.OTelEndpointConfig.String(), "OTelEndpointConfig", "OTelEndpointConfig", 1) + `,`,
		`PluginConfig:` + strings.Replace(this.PluginConfig.String(), "PluginConfig", "PluginConfig", 1) + `,`,
		`DebugInfo:` + strings.Replace(this.DebugInfo.String(), "DebugInfo", "DebugInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LogicalPlannerResult) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LogicalPlannerResult{`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "statuspb.Status", 1) + `,`,
		`Plan:` + strings.Replace(this.Plan.String(), "DistributedPlan", "DistributedPlan", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDistributedPlan(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *MetadataInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MetadataInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MetadataInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v metadatapb.MetadataType
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDistributedPlan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= metadatapb.MetadataType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.MetadataFields = append(m.MetadataFields, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDistributedPlan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthDistributedPlan
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthDistributedPlan
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.MetadataFields) == 0 {
					m.MetadataFields = make([]metadatapb.MetadataType, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v metadatapb.MetadataType
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= metadatapb.MetadataType(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.MetadataFields = append(m.MetadataFields, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataFields", wireType)
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field XXHash64BloomFilter", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &bloomfilterpb.XXHash64BloomFilter{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Filter = &MetadataInfo_XXHash64BloomFilter{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CarnotInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CarnotInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CarnotInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryBrokerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueryBrokerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasGRPCServer", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasGRPCServer = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GRPCAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GRPCAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasDataStore", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasDataStore = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessesData", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ProcessesData = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptsRemoteSources", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AcceptsRemoteSources = bool(v != 0)
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TableInfo = append(m.TableInfo, &TableInfo{})
			if err := m.TableInfo[len(m.TableInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ASID", wireType)
			}
			m.ASID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ASID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetadataInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetadataInfo == nil {
				m.MetadataInfo = &MetadataInfo{}
			}
			if err := m.MetadataInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AgentID == nil {
				m.AgentID = &uuidpb.UUID{}
			}
			if err := m.AgentID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SSLTargetName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SSLTargetName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TableInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TableInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TableInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Table", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Table = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TabletizationKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TabletizationKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tablets", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tablets = append(m.Tablets, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SchemaInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SchemaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SchemaInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &schemapb.Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentList", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AgentList = append(m.AgentList, &uuidpb.UUID{})
			if err := m.AgentList[len(m.AgentList)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DistributedState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DistributedState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DistributedState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CarnotInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CarnotInfo = append(m.CarnotInfo, &CarnotInfo{})
			if err := m.CarnotInfo[len(m.CarnotInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SchemaInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SchemaInfo = append(m.SchemaInfo, &SchemaInfo{})
			if err := m.SchemaInfo[len(m.SchemaInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DistributedPlan) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DistributedPlan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DistributedPlan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QbAddressToPlan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.QbAddressToPlan == nil {
				m.QbAddressToPlan = make(map[string]*planpb.Plan)
			}
			var mapkey string
			var mapvalue *planpb.Plan
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDistributedPlan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &planpb.Plan{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDistributedPlan(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.QbAddressToPlan[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QbAddressToDagId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.QbAddressToDagId == nil {
				m.QbAddressToDagId = make(map[string]uint64)
			}
			var mapkey string
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDistributedPlan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDistributedPlan(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.QbAddressToDagId[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dag", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dag == nil {
				m.Dag = &planpb.DAG{}
			}
			if err := m.Dag.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RedactionOptions) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RedactionOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RedactionOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseFullRedaction", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseFullRedaction = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UsePxRedactPiiBestEffort", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UsePxRedactPiiBestEffort = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OTelEndpointConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OTelEndpointConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OTelEndpointConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field URL", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.URL = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Headers == nil {
				m.Headers = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowDistributedPlan
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowDistributedPlan
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDistributedPlan(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthDistributedPlan
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Headers[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			m.Timeout = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timeout |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PluginConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PluginConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PluginConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeNs", wireType)
			}
			m.StartTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTimeNs", wireType)
			}
			m.EndTimeNs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndTimeNs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DebugInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OtelDebugAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OtelDebugAttributes = append(m.OtelDebugAttributes, &DebugInfo_OTelDebugAttribute{})
			if err := m.OtelDebugAttributes[len(m.OtelDebugAttributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugInfo_OTelDebugAttribute) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OTelDebugAttribute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OTelDebugAttribute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogicalPlannerState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LogicalPlannerState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogicalPlannerState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DistributedState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DistributedState == nil {
				m.DistributedState = &DistributedState{}
			}
			if err := m.DistributedState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlanOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PlanOptions == nil {
				m.PlanOptions = &planpb.PlanOptions{}
			}
			if err := m.PlanOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResultAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultSSLTargetName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResultSSLTargetName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedactionOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RedactionOptions == nil {
				m.RedactionOptions = &RedactionOptions{}
			}
			if err := m.RedactionOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OTelEndpointConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OTelEndpointConfig == nil {
				m.OTelEndpointConfig = &OTelEndpointConfig{}
			}
			if err := m.OTelEndpointConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PluginConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PluginConfig == nil {
				m.PluginConfig = &PluginConfig{}
			}
			if err := m.PluginConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DebugInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DebugInfo == nil {
				m.DebugInfo = &DebugInfo{}
			}
			if err := m.DebugInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogicalPlannerResult) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LogicalPlannerResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogicalPlannerResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &statuspb.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Plan == nil {
				m.Plan = &DistributedPlan{}
			}
			if err := m.Plan.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDistributedPlan(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDistributedPlan
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDistributedPlan(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowDistributedPlan
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDistributedPlan
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthDistributedPlan
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDistributedPlan
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDistributedPlan
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDistributedPlan        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDistributedPlan          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDistributedPlan = fmt.Errorf("proto: unexpected end of group")
)
